/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.skatiger.jrove.util;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ClassUtil {
    protected static final String[] EMPTY_STRING = new String[0];

    protected static final String[] PRIMITIVE_NAMES = new String[] { "boolean",
                                                                    "byte",
                                                                    "char",
                                                                    "double",
                                                                    "float",
                                                                    "int",
                                                                    "long",
                                                                    "short",
                                                                    "void" };

    protected static final Class<?>[] PRIMITIVES = new Class[] { boolean.class,
                                                                byte.class,
                                                                char.class,
                                                                double.class,
                                                                float.class,
                                                                int.class,
                                                                long.class,
                                                                short.class,
                                                                Void.TYPE };

    public static Class<?> forName(String name) throws ClassNotFoundException {
        if (null == name || "".equals(name)) {
            return null;
        }
        Class<?> c = forNamePrimitive(name);
        if (c == null) {
            if (name.endsWith("[]")) {
                String nc = name.substring(0, name.length() - 2);
                c = Class.forName(nc, false, Thread.currentThread()
                        .getContextClassLoader());
                c = Array.newInstance(c, 0).getClass();
            } else {
                c = Class.forName(name, false, Thread.currentThread()
                        .getContextClassLoader());
            }
        }
        return c;
    }

    public static <T> T newInstance(Class<T> clazz)
            throws InstantiationException, IllegalAccessException {
        T t = clazz.newInstance();
        return t;
    }

    protected static Class<?> forNamePrimitive(String name) {
        if (name.length() <= 8) {
            int p = Arrays.binarySearch(PRIMITIVE_NAMES, name);
            if (p >= 0) {
                return PRIMITIVES[p];
            }
        }
        return null;
    }

    protected static final String paramString(Class<Object>[] types) {
        if (types != null) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < types.length; i++) {
                sb.append(types[i].getName()).append(", ");
            }
            if (sb.length() > 2) {
                sb.setLength(sb.length() - 2);
            }
            return sb.toString();
        }
        return null;
    }

    /**
     * Converts an array of Class names to Class types
     * 
     * @param s
     * @return
     * @throws ClassNotFoundException
     */
    public static Class<?>[] toTypeArray(String[] s)
            throws ClassNotFoundException {
        if (s == null) {
            return null;
        }
        Class<?>[] c = new Class[s.length];
        for (int i = 0; i < s.length; i++) {
            c[i] = forName(s[i]);
        }
        return c;
    }

    /**
     * Converts an array of Class types to Class names
     * 
     * @param c
     * @return
     */
    public static String[] toTypeNameArray(Class<?>[] c) {
        if (c == null) {
            return null;
        }
        String[] s = new String[c.length];
        for (int i = 0; i < c.length; i++) {
            s[i] = c[i].getName();
        }
        return s;
    }

    /**
     * 
     */
    private ClassUtil() {
    }
}
